package com.example.demo.mbp.entity;

import lombok.Data;
import org.springframework.util.CollectionUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 查询条件组（可包含多个条件或子组）
 */
@Data
public class QueryGroup implements Serializable {
    private static final long serialVersionUID = 1L;
    
    // 连接类型（and/or）
    private String connector;
    
    // 条件列表
    private List<QueryCondition> conditions;
    
    // 子查询组列表
    private List<QueryGroup> groups;
    
    // 允许的连接符列表
    private static final List<String> ALLOWED_CONNECTORS = Arrays.asList("and", "or");
    
    /**
     * 验证查询组是否有效
     */
    public boolean isValid() {
        // 验证连接符
        if (!ALLOWED_CONNECTORS.contains(connector.toLowerCase())) {
            return false;
        }
        
        // 条件列表和子组列表不能同时为空
        if (CollectionUtils.isEmpty(conditions) && CollectionUtils.isEmpty(groups)) {
            return false;
        }
        
        // 验证条件列表
        if (!CollectionUtils.isEmpty(conditions)) {
            for (QueryCondition condition : conditions) {
                if (condition == null || !condition.isValid()) {
                    return false;
                }
            }
        }
        
        // 验证子查询组
        if (!CollectionUtils.isEmpty(groups)) {
            for (QueryGroup group : groups) {
                if (group == null || !group.isValid()) {
                    return false;
                }
            }
        }
        
        return true;
    }
    
    /**
     * 标准化查询组（如转换为小写）
     */
    public void normalize() {
        // 连接符转为小写
        if (connector != null) {
            connector = connector.toLowerCase();
        }
        
        // 标准化条件
        if (!CollectionUtils.isEmpty(conditions)) {
            conditions = conditions.stream()
                .filter(Objects::nonNull)
                .peek(QueryCondition::normalize)
                .collect(Collectors.toList());
        }
        
        // 标准化子查询组
        if (!CollectionUtils.isEmpty(groups)) {
            groups = groups.stream()
                .filter(Objects::nonNull)
                .peek(QueryGroup::normalize)
                .collect(Collectors.toList());
        }
    }
    
    /**
     * 添加条件
     */
    public QueryGroup addCondition(QueryCondition condition) {
        if (condition == null) {
            return this;
        }
        
        if (conditions == null) {
            conditions = new ArrayList<>();
        }
        
        conditions.add(condition);
        return this;
    }
    
    /**
     * 添加子查询组
     */
    public QueryGroup addGroup(QueryGroup group) {
        if (group == null) {
            return this;
        }
        
        if (groups == null) {
            groups = new ArrayList<>();
        }
        
        groups.add(group);
        return this;
    }
}    